package forkJoinDemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo1 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyTask myTask=new MyTask(0,100);
        //这是Fork/Join框架的线程池
        ForkJoinPool forkJoinPool=new ForkJoinPool();
        Integer submit = forkJoinPool.invoke(myTask);
        System.out.println("得到的结果是："+submit);
        //使用完要关闭
        forkJoinPool.shutdown();


    }

   public static class MyTask extends RecursiveTask<Integer>{

        private int begin;
        private int end;
        private int result;
        //定义一个阈值，用来决定任务拆分的最小粒度
        private int yuzhi=10;

        public MyTask(int begin, int end) {
            this.begin = begin;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            /**
             * 如果条件成立，说明这个任务所需要计算的数值分为足够小了，可以正式进行累加计算了
             * 若在10以内则说明需要计算的数据量不大，所以就不需要拆分
             */

            if ((end-begin)<=yuzhi){
                for (int i=begin;i<=end;i++){
                    result=result+i;
                }
            }
            /**
             * 否则再进行任务拆分，拆分成两个任务
             */
            else {
                int middle=(end+begin)/2;
                MyTask myTask = new MyTask(begin, middle);
                MyTask myTask2 = new MyTask(middle+1, end);
                /**
                 * 分叉：调用fork()方法则会自动调用myTask的compute()方法，这就相当于递归了
                 */
                myTask.fork();
                myTask2.fork();
                //调用join进行归约，也就是获取每个fork的结果之后，做求和操作
                result=myTask.join()+myTask2.join();
            }
            //将结果返回
            return result;
        }
    }
}
